import java.util.Arrays;
import java.util.Scanner;

public class 蜗牛 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 输入竹竿数
        int n = scanner.nextInt();
        // 记录每根竹竿的横坐标
        int[] bamboo = new int[n];
        // 输入每根竹竿离原点的横坐标距离
        for (int i = 0; i < n; i++)
            bamboo[i] = scanner.nextInt();
        // 记录传送门坐标（最后一根竹子上没有传送点，即：0 < 竹子数 < n）
        // transmit[i][0]：传入传送门纵坐标
        // transmit[i][1]：传出传送门纵坐标
        int[][] transmit = new int[n - 1][2];
        for (int i = 0; i < n - 1; i++) {
            // 输入传入传送门纵坐标
            transmit[i][0] = scanner.nextInt();
            // 输入传出传送门纵坐标
            transmit[i][1] = scanner.nextInt();
        }
        // Dynamic Programming（动态规划）
        // dp[i][0]：从 i - 1 点到第 i 根竹子最短时间（不使用传送门）
        // dp[i][1]：从 i - 1 点到第 i 根竹子最短时间（使用传送门）
        double[][] dp = new double[n][2];
        for (int i = 0; i < n; i++)
            // 初始化 dp 数组（将 dp 数组的每一位填入最大值）
            Arrays.fill(dp[i], Integer.MAX_VALUE);
        // 当只有一根竹子时，即：没有传送门，不需要考虑传送门
        if (n == 1) {
            System.out.printf("%.2f", (double) bamboo[0]);
        } else {
            // 原点到第一根竹子的最短时间固定为直接走过去的时间（横坐标上 1m/s）
            dp[0][0] = bamboo[0];
            /// 手动判别前两根竹竿所需的最短时间（判断直接走的时间短还是使用传送门的时间短）
            // 第一根竹竿到达第二根竹竿不使用传送门
            dp[1][0] = Math.min(dp[0][0] + bamboo[1] - bamboo[0], dp[1][0]);
            // 第一根竹竿到达第二跟竹竿使用传送门（原点到第一根竹竿走的最短时间 + 爬上第一根竹竿传入传送门的时间
            dp[1][1] = Math.min(dp[0][0] + transmit[0][0] / 0.7, dp[1][1]);
            /// 不断判别 “第三根 ” 竹竿的最短时间
            for (int i = 2; i < n; i++) {

                // 不使用传送门到达前一根竹竿，且前一根竹竿到当前竹竿不使用传送门
                dp[i][0] = Math.min(dp[i - 1][0] + bamboo[i] - bamboo[i - 1], dp[i][0]);

                // 使用传送门到达前一根竹竿，且前一根竹竿到当前竹竿不使用传送门
                // （注意得加上前前一根竹竿上记录的传出传送门所在的位置到当前竹竿底部的位置所需时间）
                dp[i][0] = Math.min(dp[i - 1][1] + transmit[i - 2][1] / 1.3 + bamboo[i] - bamboo[i - 1], dp[i][0]);

                // 不使用传送门到达前一根竹竿，且前一根竹竿到当前竹竿使用传送门
                // （注意得加上爬上前一根竹竿上记录的传入传送门所在的位置的所需时间）
                dp[i][1] = Math.min(dp[i - 1][0] + transmit[i - 1][0] / 0.7, dp[i][1]);

                // 使用传送门到达前一根竹竿，且前一根竹竿到当前竹竿使用传送门
                // （注意得判别前前一根竹竿上记录的传出传送门所在位置与前一根竹竿上记录的传入传送门所在位置谁大谁小）
                // 记录速率（初始化位上升速率）
                double rate = 0.7;
                if(transmit[i - 2][1] > transmit[i - 1][0])
                    rate = 1.3;
                dp[i][1] = Math.min(dp[i - 1][1] + Math.abs(transmit[i - 2][1] - transmit[i - 1][0]) / rate, dp[i][1]);
            }
            // 最短时间 Math.min(前一根竹竿不使用传送门，前一根竹竿使用传送门)
            // （注意前一根竹竿使用传送门的情况下得加上前前一根竹竿上记录的传出传送门所在的位置到最后一根竹竿底部的位置所需时间）
            double minTime = Math.min(dp[n - 1][0], dp[n - 1][1] + transmit[n - 2][1] / 1.3);
            // 输出结果
            System.out.printf("%.2f", minTime);
        }
    }
}
